package org.beehoo.web.framework.util;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.springframework.util.Assert;

/**
 * 
 * String的相关工具类
 * 
 * @author duxb
 * @version $Revision$$Date$
 * @created 2010-9-3 下午01:58:26
 * @history
 * @see
 */
public class StringUtil {

	/**
	 * 空值
	 */
	public static final String EMPTY = "";

	/**
	 * 得到指定分割符之前的str（str中左起第一个分割符之前）
	 * 
	 * @param str源字符串
	 * @param separator分割符
	 * @return 指定分割符之前的str
	 * @author dingxiaodong
	 * @created 2010-9-14 下午03:06:04
	 */
	public static String substringBefore(String str, String separator) {
		if (isNullString(str) || separator == null)
			return str;
		if (separator.length() == 0)
			return EMPTY;
		int pos = indexOfIgnoreCase(str, separator);
		if (pos == -1)
			return str;
		return str.substring(0, pos);
	}

	/**
	 * 得到指定分割符之后的str（str中左起第一个分割符之后）
	 * 
	 * @param str源字符串
	 * @param separator分割符
	 * @return 指定分割符之后的str
	 * @author dingxiaodong
	 * @created 2010-9-14 下午03:06:27
	 */
	public static String substringAfter(String str, String separator) {
		if (str == null || str.trim().equals(EMPTY))
			return str;
		if (separator == null)
			return EMPTY;
		int pos = indexOfIgnoreCase(str, separator);
		if (pos == -1)
			return EMPTY;
		return str.substring(pos + separator.length());
	}

	/**
	 * 得到搜索字符在str中的位置下标（左起第一个，大小写不敏感）
	 * 
	 * @param str
	 *            源字符串
	 * @param searchStr
	 *            要搜索的字符串
	 * @return 搜索字符在str中的位置下标（左起第一个）
	 * @author dingxiaodong
	 * @created 2010-9-14 下午03:10:58
	 */
	public static int indexOfIgnoreCase(String str, String searchStr) {
		return indexOfIgnoreCase(str, searchStr, 0);
	}

	/**
	 * 得到搜索字符在str中的位置下标（左起startPos个字符之后，大小写不敏感）
	 * 
	 * @param str
	 *            源字符串
	 * @param searchStr
	 *            要搜索的字符串
	 * @param startPos
	 *            搜索开始位置
	 * @return 得到搜索字符在str中的位置下标（左起startPos个字符之后）
	 * @author dingxiaodong
	 * @created 2010-9-14 下午03:12:52
	 */
	public static int indexOfIgnoreCase(String str, String searchStr, int startPos) {
		int spos = startPos;
		if (str == null || searchStr == null)
			return -1;
		if (spos < 0) {
			spos = 0;
		}
		int endLimit = (str.length() - searchStr.length()) + 1;
		if (spos > endLimit)
			return -1;
		if (searchStr.length() == 0)
			return spos;
		for (int i = spos; i < endLimit; i++) {
			if (str.regionMatches(true, i, searchStr, 0, searchStr.length()))
				return i;
		}
		return -1;
	}

	/**
	 * 将字符串用单引号括起来,并进行单引号的转义. 该函数通常用于数据库存储. ex: abc -> 'abc' 、I'm bright -> 'I''m bright'
	 * 
	 * @param s
	 *            需要转移的字符串
	 * @return 转移后的结果
	 * @author dingxiaodong
	 * @created 2010-9-14 下午03:32:53
	 */
	public static String singleQuotoAndEscape(String str) {
		if (!isNullString(str)) {
			StringBuffer t = new StringBuffer(str.length() + 3);
			t.append("'");
			t.append(str.replaceAll("'", "''"));
			t.append("'");
			return t.toString();
		}
		return "''";
	}
	
	/**
	 * 将数组中的字符串用单引号括起来,并进行单引号的转义. 该函数通常用于数据库存储. ex: abc -> 'abc' 、I'm bright -> 'I''m bright'
	 * 
	 * @param s
	 *            需要转移的字符串
	 * @return 转移后的结果
	 * @author dingxiaodong
	 * @created 2010-9-14 下午03:32:53
	 */
	public static String[] singleQuotoAndEscape(String[] strs) {
		String[] result=new String[strs.length];
		for(int i=0;i<strs.length;i++){
			String str=strs[i];
			result[i]=singleQuotoAndEscape(str);
		}
		return result;
	}

	/**
	 * 判断一个字符串是否为空。 这包括s == null或s去除了尾部空格后长度为0两种情况。
	 * 
	 * @param str
	 * @return 如果为空返回true,否则返回false
	 * @author dingxiaodong
	 * @created 2010-9-14 下午04:04:12
	 */
	public static final boolean isNullString(String str) {
		return str == null || str.length() == 0 || str.trim().length() == 0;
	}

	/**
	 * 将字符串str以separator分割储存在List中返回。注意用 "," 分割"1," list.size为1。分割",1" list.size为2。支持特殊字符(!@#$%^&*|.?），使用\n\r\t搜索时，入参应该为\\t..形式 找不到分割符时返回只包含原string的list
	 * 
	 * @param str
	 *            待操作的字符串
	 * @param separator
	 *            分割符
	 * @return 储存分割后的字符串的List
	 * @author dingxiaodong
	 * @created 2010-9-14 下午04:07:07
	 */
	public static List<String> splitToList(String str, String separator) {
		// str为null时返回null
		if (null == str)
			return null;
		ArrayList<String> list = new ArrayList<String>();
		String realSeparator = separator;
		if (!str.equals("")) {
			// 是\t\n\r形式
			if ("\\n".startsWith(realSeparator) || "\\r".startsWith(realSeparator) || "\\t".startsWith(realSeparator)) {
				realSeparator = "\\" + realSeparator;
			} else {
				// 是+*?\
				if (realSeparator.startsWith("+") || realSeparator.startsWith("*") || realSeparator.startsWith("?") || realSeparator.startsWith("\\")) {
					realSeparator = "\\" + realSeparator;
				} else {
					Pattern p = Pattern.compile(realSeparator.charAt(0) + "");
					Matcher m = p.matcher("~!@#$%^&.<>-|");
					// 是~!@#$%^&.<>-|
					if (m.find()) {
						realSeparator = "\\" + realSeparator;
					}
				}
			}
			String[] array = str.split(realSeparator);
			for (int i = 0; i < array.length; i++) {
				list.add(array[i]);
			}
		}
		return list;
	}

	/**
	 *将一个字符串以 | 分割，并将结果储存在List中返回．比如 "|a||b|c|" 期望的结果为 "", "a", "", "b", "c"，最后一个根据String规则，省略最后一个空值 。找不到分割符时返回只包含原string的list
	 * 
	 * @param str
	 *            待操作的字符串
	 * @return 储存分割后的字符串的List
	 * @author dingxiaodong
	 * @created 2010-9-14 下午04:24:54
	 */
	public static List<String> splitToListByUpStraight(String str) {
		List<String> list = new ArrayList<String>();
		if (null == str)
			return null;
		if (str.equals("")) {
			list.add("");
			return list;
		}
		String[] array = str.split("\\|");
		for (int i = 0; i < array.length; i++) {
			list.add(array[i]);
		}
		return list;
	}

	/**
	 * 将str中的StrsToReplace(单个值或数组)替换为空值（""）
	 * 
	 * @param str
	 *            要进行替换操作的的字符串
	 * @param StrsToReplace
	 *            要替换的字符串（单个值或数组）
	 * @return 替换后的字符串
	 * @author dingxiaodong
	 * @created 2010-9-17 上午11:24:53
	 */
	public static String repaceAllToEmpty(String str, String... stringsToReplace) {
		if (null == str)
			return null;
		if (0 == stringsToReplace.length)
			return str;
		String replacedStr = str;
		for (String toReplace : stringsToReplace) {
			if (null != toReplace && !"".equals(toReplace)) {
				// 特殊字符
				if ("\\n".startsWith(toReplace) || "\\r".startsWith(toReplace) || "\\t".startsWith(toReplace)) {
					toReplace = "\\" + toReplace;
				} else {
					// 是+*?\
					if (toReplace.startsWith("+") || toReplace.startsWith("*") || toReplace.startsWith("?") || toReplace.startsWith("\\")) {
						toReplace = "\\" + toReplace;
					} else {
						Pattern p = Pattern.compile(toReplace.charAt(0) + "");
						Matcher m = p.matcher("~!@#$%^&.<>-|");
						// 是~!@#$%^&.<>-|
						if (m.find()) {
							toReplace = "\\" + toReplace;
						}
					}
				}
				// 进行替换
				replacedStr = replacedStr.replaceAll(toReplace, EMPTY);
			}
		}
		return replacedStr;
	}

	/**
	 * 将str中的StrsToReplace(单个值或数组)替换为targetValue
	 * 
	 * @param str
	 *            要进行替换操作的的字符串
	 * @param StrsToReplace
	 *            要替换的字符串（单个值或数组）
	 * @return 替换后的字符串
	 * @author dingxiaodong
	 * @created 2010-9-17 上午11:24:53
	 */
	public static String repaceAllToTargetValue(String str, String targetValue, String... stringsToReplace) {
		if (null == str)
			return null;
		if (0 == stringsToReplace.length)
			return str;
		String replacedStr = str;
		for (String toReplace : stringsToReplace) {
			if (null != toReplace && !"".equals(toReplace)) {
				// 特殊字符
				if ("\\n".startsWith(toReplace) || "\\r".startsWith(toReplace) || "\\t".startsWith(toReplace)) {
					toReplace = "\\" + toReplace;
				} else {
					// 是+*?\
					if (toReplace.startsWith("+") || toReplace.startsWith("*") || toReplace.startsWith("?") || toReplace.startsWith("\\")) {
						toReplace = "\\" + toReplace;
					} else {
						Pattern p = Pattern.compile(toReplace.charAt(0) + "");
						Matcher m = p.matcher("~!@#$%^&.<>-|");
						// 是~!@#$%^&.<>-|
						if (m.find()) {
							toReplace = "\\" + toReplace;
						}
					}
				}
				// 进行替换
				replacedStr = replacedStr.replaceAll(toReplace, targetValue);
			}
		}
		return replacedStr;
	}

	/**
	 * 
	 * 将一组String按造给定的分隔符拼成串
	 * 
	 * @param coll
	 *            字符串集合
	 * @param seperator
	 *            分隔符
	 * @return 返回拼好的字符串，如果传入的字符串集合为空则返回""
	 * @author zhaopq
	 * @created 2010-12-15 上午10:11:02
	 */
	public static String combineToString(Collection<String> coll, String seperator) {
		Assert.notNull(seperator);
		if (coll == null)
			return EMPTY;
		StringBuilder result = new StringBuilder();

		for (String str : coll) {
			if (str != null) {
				result.append(str).append(seperator);
			}
		}
		if (result.length() > seperator.length()) {
			result.setLength(result.length() - seperator.length());
		}

		return result.toString();

	}

	/**
	 * 忽略大小写得到str中在separator之后的字符串
	 * 
	 * @param str
	 * @param separator
	 * @return
	 * @author dingxiaodong
	 * @created 2011-3-2 下午07:49:43
	 */
	public static String substringAfterLastIgnoreCase(String str, String separator) {
		Assert.notNull(str);
		Assert.notNull(separator);
		if (str.equals(""))
			return str;
		if (separator.equals(""))
			return str;
		String tempStr = str.toUpperCase();
		String tempSeparator = separator.toUpperCase();

		int index = tempStr.lastIndexOf(tempSeparator);
		String result = str.substring(index + separator.length());
		return result;
	}

	/**
	 * 忽略大小写得到str中在separator之前的字符串
	 * 
	 * @param str
	 * @param separator
	 * @return
	 * @author dingxiaodong
	 * @created 2011-3-2 下午07:49:46
	 */
	public static String substringBeforeLastIgnoreCase(String str, String separator) {
		Assert.notNull(str);
		Assert.notNull(separator);
		if (str.equals(""))
			return str;
		if (separator.equals(""))
			return str;
		String tempStr = str.toUpperCase();
		String tempSeparator = separator.toUpperCase();

		int index = tempStr.lastIndexOf(tempSeparator);
		String result = str.substring(0, index);
		return result;
	}

	public static void main(String[] args) {
		String[]  strs = StringUtil.singleQuotoAndEscape(new String[]{"1","2"});
		System.out.println(strs[0]);
	}
}